/*
 * Copyright (c) 2024 endless-sky
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _HAL_STRUCT_H_
#define _HAL_STRUCT_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

/* 常用返回码（保持现有调用兼容） */
#ifndef HAL_SUCCESS
#define HAL_SUCCESS (0)
#endif
#ifndef HAL_FAILURE
#define HAL_FAILURE (-1)
#endif

/*----------------------------------------------------------------------------*/
/*                                 宏定义                                     */
/*----------------------------------------------------------------------------*/

#define MAX_SES_NUM (2u)        // 最大 Sensor 数量
#define MAX_SES_FRAMERATE (30u) // Sensor 最大帧率
#define HAL_VO_MAX_CHN (1u)     // 视频输出 (VO) 最大通道数
#define VENC_CHAN_MAX (5u)      // 单个视频输入 (VI) 支持的最大编码 (VENC) 通道数
#define YUV_CHAN_MAX (2u)       // YUV 通道最大数量

/* 通道命名约定 */
#define HAL_MAIN_STREAM_CHAN (0)   // 主码流通道索引
#define HAL_SUB_STREAM_CHAN (1)    // 子码流通道索引
#define HAL_JPEG_STREAM_CHAN (2)   // JPEG 抓图通道索引
#define HAL_AO_STREAM_CHAN (3)     // 音频输出 (AO) 通道索引 (注意: 此宏命名可能与音频相关)
#define HAL_AIJEPG_STREAM_CHAN (4) // AI JPEG 抓图通道索引

// 音频输入 (AI) 最大通道数
#define HAL_AI_MAX_CHN (1u)
// 音频输入 (AI) 最大音量 (范围通常为 0-100)
#define HAL_AI_MAX_VOL (100u)
// 音频输出 (AO) 最大通道数
#define HAL_AO_MAX_CHN (1u)
// 音频输出 (AO) 最大音量 (范围通常为 0-100)
#define HAL_AO_MAX_VOL (100u)

// OSD 字库文件路径最大长度 (包括 '\0')
#define HAL_OSD_MAX_FONT_LEN (128u)
// OSD 区域最大数量
#define HAL_OSD_MAX_NUM (4u)
// OSD 区域用于显示时间的固定索引
#define HAL_OSD_TIME_IDX (0u)
// OSD 区域用于显示自定义标题的最大长度 (包括 '\0')
#define HAL_OSD_TITLE_LEN (64u)

/*----------------------------------------------------------------------------*/
/*                                 通用结构体定义                             */
/*----------------------------------------------------------------------------*/
// 整型二维点坐标
typedef struct _HAL_BASE_POINT_S_ {
    uint32_t u32X; // 横坐标 (X)
    uint32_t u32Y; // 纵坐标 (Y)
} HAL_BASE_POINT_S;

// 整型矩形区域
typedef struct _HAL_BASE_RECT_S_ {
    uint32_t u32X;      // 矩形左上角横坐标
    uint32_t u32Y;      // 矩形左上角纵坐标
    uint32_t u32Width;  // 矩形宽度
    uint32_t u32Height; // 矩形高度
} HAL_BASE_RECT_S;

/*----------------------------------------------------------------------------*/
/*                                 音频结构体定义                             */
/*----------------------------------------------------------------------------*/
// 音频采样率枚举
typedef enum _HAL_AUDIO_SAMPLE_RATE_E_ {
    HAL_AUDIO_SAMPLE_RATE_INVALID = 0x0, // 无效采样率

    HAL_AUDIO_SAMPLE_RATE_8000,  // 8kHz
    HAL_AUDIO_SAMPLE_RATE_11025, // 11.025kHz
    HAL_AUDIO_SAMPLE_RATE_12000, // 12kHz
    HAL_AUDIO_SAMPLE_RATE_16000, // 16kHz
    HAL_AUDIO_SAMPLE_RATE_22050, // 22.05kHz
    HAL_AUDIO_SAMPLE_RATE_24000, // 24kHz
    HAL_AUDIO_SAMPLE_RATE_32000, // 32kHz
    HAL_AUDIO_SAMPLE_RATE_44100, // 44.1kHz
    HAL_AUDIO_SAMPLE_RATE_48000, // 48kHz
    HAL_AUDIO_SAMPLE_RATE_64000, // 64kHz
    HAL_AUDIO_SAMPLE_RATE_96000, // 96kHz

    HAL_AUDIO_SAMPLE_RATE_BUTT, // 枚举结束标记
} HAL_AUDIO_SAMPLE_RATE_E;

// 音频采样位宽枚举
typedef enum _HAL_AUDIO_BIT_WIDTH_E_ {
    HAL_AUDIO_BIT_WIDTH_8 = 0,  // 8 位
    HAL_AUDIO_BIT_WIDTH_16 = 1, // 16 位
    HAL_AUDIO_BIT_WIDTH_24 = 2, // 24 位
    HAL_AUDIO_BIT_WIDTH_32 = 3, // 32 位
    HAL_AUDIO_BIT_WIDTH_BUTT,   // 枚举结束标记
} HAL_AUDIO_BIT_WIDTH_E;

// 音频编解码类型枚举
typedef enum _AUDIO_COM_TYPE_ {
    HAL_AUDIO_TYPE_INVALID = 0x0, // 无效类型

    HAL_AUDIO_TYPE_G711_A, // G.711 A-law
    HAL_AUDIO_TYPE_G711_U, // G.711 μ-law
    HAL_AUDIO_TYPE_G726,   // G.726 ADPCM
    HAL_AUDIO_TYPE_ADPCM,  // ADPCM
    HAL_AUDIO_TYPE_AAC,    // Advanced Audio Coding
    HAL_AUDIO_TYPE_MP3,    // MPEG-1 Audio Layer III
    HAL_AUDIO_TYPE_OPUS,   // Opus Interactive Audio Codec

    HAL_AUDIO_TYPE_BUTT, // 枚举结束标记
} HAL_AUDIO_TYPE_E;

// 音频编码 (AENC) 通用配置参数
typedef struct _AENC_COM_CONFIG_ {
    HAL_AUDIO_SAMPLE_RATE_E u32SampleRate; // 采样率
    HAL_AUDIO_BIT_WIDTH_E u32BitWidth;     // 采样位宽
    HAL_AUDIO_TYPE_E eType;                // 编码类型
    uint8_t u32SpkNum;                     // 采集通道数 (1: 单声道, 2: 立体声)
    uint8_t u8Vol;                         // 音量 (范围通常为 0-100)
    uint8_t res[6];                        // 保留字段 (用于对齐)
} HAL_AENC_COM_CONFIG_S;

// 音频解码 (ADEC) 通用配置参数
typedef struct _ADEC_COM_CONFIG_ {
    HAL_AUDIO_SAMPLE_RATE_E u32SampleRate; // 采样率
    HAL_AUDIO_TYPE_E eType;                // 解码类型
    uint8_t u8ChanNum;                     // 输出通道数 (1: 单声道, 2: 立体声)
    uint8_t u8Vol;                         // 音量 (范围通常为 0-100)
    uint8_t res[6];                        // 保留字段 (用于对齐)
} HAL_ADEC_COM_CONFIG_S;

// 音频编码码流信息
typedef struct _HAL_AENC_STREAM_S_ {
    uint64_t u64TimeStamp; // 时间戳 (单位: 微秒 us)
    uint32_t u32Seq;       // 帧序号
    uint32_t u32DataLen;   // 码流帧数据长度 (字节)
    uint8_t *pData;        // 码流数据指针 (内存由内部模块申请和管理)
    uint8_t *pRelHandler;  // 底层资源释放句柄 (用于释放 pData 指向的内存)
    uint8_t res[4];        // 保留字段 (用于对齐)
} HAL_AENC_STREAM_S;

/*----------------------------------------------------------------------------*/
/*                            视频输入 (VI) 结构体定义                        */
/*----------------------------------------------------------------------------*/

// Sensor 驱动类型枚举
typedef enum _HAL_DRV_TYPE_E_ {
    HAL_DRV_TYPE_IMS290 = 0x0,
    HAL_DRV_TYPE_0S05A,
    HAL_DRV_TYPE_0S02K10,
    HAL_DRV_TYPE_AR0237IR,
    HAL_DRV_TYPE_OV2736IR,
    HAL_DRV_TYPE_IMX335,
    HAL_DRV_TYPE_SC4336,
    HAL_DRV_TYPE_IMX415,
    HAL_DRV_TYPE_500AI,
    HAL_DRV_TYPE_IMX327,
    HAL_DRV_TYPE_GC4663,
    HAL_DRV_TYPE_F37P,
    HAL_DRV_TYPE_K05,
    HAL_DRV_TYPE_OV4689,
    HAL_DRV_TYPE_SC830AI,
    HAL_DRV_TYPE_GC4653,
    HAL_DRV_TYPE_SC430AI,
    HAL_DRV_TYPE_OS04C10,
    // 后续可添加更多 Sensor 型号
} HAL_DRV_TYPE_E;

// 单个 Sensor 驱动配置项
typedef struct _HAL_SENDRV_ITEM_S_ {
    HAL_DRV_TYPE_E u8DrvIdx; // Sensor 驱动类型 (对应 HAL_DRV_TYPE_E)
    uint8_t res[4];          // 保留字段 (用于对齐)
} HAL_SENDRV_ITEM_S;

// 整体 Sensor 驱动配置
typedef struct _HAL_SENDRV_S_ {
    uint8_t u8SenNum;                        // 实际使用的 Sensor 数量
    uint8_t res[7];                          // 保留字段 (用于对齐)
    HAL_SENDRV_ITEM_S stSenDrv[MAX_SES_NUM]; // 各 Sensor 的驱动配置
} HAL_SENDRV_S;

// 视频输入镜像/翻转配置
typedef struct _HAL_VI_MIRROR_CFG_S_ {
    bool bMirror; // 是否启用水平镜像 (true: 启用, false: 禁用)
    bool bFlip;   // 是否启用垂直翻转 (true: 启用, false: 禁用)
} HAL_VI_MIRROR_CFG_S;

/*----------------------------------------------------------------------------*/
/*                            视频 OSD 结构体定义                             */
/*----------------------------------------------------------------------------*/
// OSD 字库文件配置
typedef struct _HAL_OSD_FONT_S_ {
    char cFilename[HAL_OSD_MAX_FONT_LEN]; // 字库文件路径 (以 '\0' 结尾的字符串)
} HAL_OSD_FONT_S;

// OSD 字体大小枚举
typedef enum _HAL_OSD_FONT_SIZE_ {
    OSD_FONT_SIZE_INVALID = 0x0, // 无效字体大小

    OSD_FONT_SIZE_16, // 16x16 像素
    OSD_FONT_SIZE_24, // 24x24 像素
    OSD_FONT_SIZE_32, // 32x32 像素
    OSD_FONT_SIZE_48, // 48x48 像素
    OSD_FONT_SIZE_64, // 64x64 像素

    OSD_FONT_SIZE_BUTT, // 枚举结束标记
} HAL_OSD_FONT_SIZE_E;

// OSD 日期格式类型枚举
typedef enum _HAL_OSD_DATE_TYPE_E_ {
    OSD_DATE_TYPE_INVALID = 0x0, // 无效日期格式

    OSD_DATE_TYPE_ENG_YMD_CROSS, // YYYY-MM-DD (英文横线)
    OSD_DATE_TYPE_ENG_MDY_CROSS, // MM-DD-YYYY (英文横线)
    OSD_DATE_TYPE_ENG_DMY_CROSS, // DD-MM-YYYY (英文横线)
    OSD_DATE_TYPE_CHN_YMD,       // YYYY年MM月DD日 (中文)
    OSD_DATE_TYPE_CHN_MDY,       // MM月DD日YYYY年 (中文)
    OSD_DATE_TYPE_CHN_DMY,       // DD日MM月YYYY年 (中文)
    OSD_DATE_TYPE_ENG_YMD_SLASH, // YYYY/MM/DD (英文斜线)
    OSD_DATE_TYPE_ENG_MDY_SLASH, // MM/DD/YYYY (英文斜线)
    OSD_DATE_TYPE_ENG_DMY_SLASH, // DD/MM/YYYY (英文斜线)

    OSD_DATE_TYPE_BUTT, // 枚举结束标记
} HAL_OSD_DATE_TYPE_E;

// OSD 时间显示配置
typedef struct _HAL_OSD_TIME_CFG_S_ {
    bool b12hour;                  // 时间制式 (true: 12小时制, false: 24小时制)
    bool bShowWeek;                // 是否显示星期 (true: 显示, false: 不显示)
    HAL_OSD_DATE_TYPE_E eDataType; // 日期格式类型
    uint8_t res[4];                // 保留字段 (用于对齐)
} HAL_OSD_TIME_CFG_S;

// OSD 区域叠加配置
typedef struct _HAL_OSD_CFG_S_ {
    bool bShow;                // 是否显示该 OSD 区域 (true: 显示, false: 隐藏)
    bool bAdaptive;            // 是否启用前景/背景色自适应 (true: 启用, false: 禁用)
    HAL_OSD_FONT_SIZE_E eSize; // 字体大小 (单位: 像素)
    uint8_t u8Idx;  // OSD 区域索引 (范围: [0, HAL_OSD_MAX_NUM - 1], HAL_OSD_TIME_IDX 固定用于时间显示)
    uint8_t res[7]; // 保留字段 (用于对齐)
    uint32_t u32FgColor;      // 前景颜色 (RGB888 格式)
    uint32_t u32BgColor;      // 背景颜色 (RGB888 格式, 可能仅在 bAdaptive=FALSE 时有效)
    HAL_BASE_POINT_S stPoint; // OSD 区域左上角在视频帧上的坐标
    union {
        HAL_OSD_TIME_CFG_S stTime; // 当 u8Idx 为 HAL_OSD_TIME_IDX 时有效, 用于时间显示配置
        char cStr[HAL_OSD_TITLE_LEN]; // 当 u8Idx 不为 HAL_OSD_TIME_IDX 时有效, 用于存储自定义 OSD 字符串 (以 '\0' 结尾)
    };
} HAL_OSD_CFG_S;

/*----------------------------------------------------------------------------*/
/*                       视频处理子系统 (VPSS) 结构体定义                      */
/*----------------------------------------------------------------------------*/
// YUV 图像像素格式枚举
typedef enum _HAL_YUV_FORMAT_E_ {
    HAL_YUV_FORMAT_YVU_SP420, // Semi-Planar YVU 4:2:0 格式 (Y平面后跟VU交错平面, VU平面宽高为Y平面一半)
    HAL_YUV_FORMAT_YUV_SP420, // Semi-Planar YUV 4:2:0 格式 (Y平面后跟UV交错平面, UV平面宽高为Y平面一半)
} HAL_YUV_FORMAT_E;

typedef struct _HAL_YUV_PARAM_INIT_S_ {
    uint32_t u32Height; /* 需要抓取的YUV数据实际高。*/
    uint32_t u32Width;  /* 需要抓取的YUV数据实际宽。*/
    uint8_t u8Fps;
    uint8_t res[7]; // 预留
} HAL_YUV_PARAM_INIT_S;

typedef struct {
    uint32_t u32Width;  /* 抓取到的YUV数据实际宽。*/
    uint32_t u32Height; /* 抓取到的YUV数据实际高。*/
    uint32_t u32FrameId;
    HAL_YUV_FORMAT_E eYuvFormat; /* YUV图像帧的像素存储格式。*/
    uint64_t u64TimeStamp;       /* YUV图像帧的显示时间戳，单位：微秒。*/
    uint8_t *pY;                 // Y数据指针
    uint32_t u32YSize;           // Y数据长度
    uint8_t *pUV;                // UV数据指针
    uint32_t u32UVSize;          // UV数据长度
    uint8_t *pRelHandler;        // 海思底层VB保存的信息的结构体的指针索引
    uint8_t res[4];              // 预留
} HAL_YUV_FRAME_S;

/*----------------------------------------------------------------------------*/
/*                                 video_venc  结构体定义                      */
/*----------------------------------------------------------------------------*/
// 码率控制类型
typedef enum _HAL_VENC_RCMODE_E_ {
    VENC_RCMODE_INVALID = 0x0,

    VENC_RCMODE_CBR, // 固定码率
    VENC_RCMODE_VBR, // 可变码率

    VENC_RCMODE_BUTT,
} HAL_VENC_RCMODE_E;

typedef enum {
    STREAM_ENCODE_TYPE_NONE = 0,
    STREAM_ENCODE_TYPE_H264 = 1,
    STREAM_ENCODE_TYPE_H265 = 2,
    STREAM_ENCODE_TYPE_JPEG = 3,
} HAL_STREAM_ENCODE_TYPE_E;

// H264特有编码参数
typedef struct _HAL_VENC_PARAM_H264_S_ {
    bool bSvc;                 // 是否SVC编码
    HAL_VENC_RCMODE_E eRcmode; // 码率控制类型
    uint32_t u32Kbps;          // 码率，单位kbps
    uint8_t u8Profile;         // 编码档次，0-2
    uint8_t u8Gop;             // I帧间隔
    uint8_t res[2];            // 预留
} HAL_VENC_PARAM_H264_S;

// H265特有编码参数
typedef struct _HAL_VENC_PARAM_H265_S_ {
    HAL_VENC_RCMODE_E eRcmode; // 码率控制类型
    uint32_t u32Kbps;          // 码率，单位kbps
    uint8_t u8Gop;             // I帧间隔
    uint8_t res[7];            // 预留
} HAL_VENC_PARAM_H265_S;

// H265特有编码参数
typedef struct _HAL_VENC_PARAM_JPEG_S_ {
    uint8_t res[8]; // 预留
} HAL_VENC_PARAM_JPEG_S;

// 视频编码参数
typedef struct _HAL_VENC_CONFIG_S_ {
    uint32_t u32Width;                  // 视频宽度
    uint32_t u32Height;                 // 视频高度
    HAL_STREAM_ENCODE_TYPE_E eProtocol; // 视频编码协议类型
    uint8_t u8Fps;                      // 帧率
    uint8_t res[3];                     // 预留
    union {
        HAL_VENC_PARAM_H264_S stH264;
        HAL_VENC_PARAM_H265_S stH265;
        HAL_VENC_PARAM_JPEG_S stJpeg;
    };
} HAL_VENC_CONFIG_S;

// 视频编码码流信息
#define VENC_PACK_MAX 4
typedef struct _HAL_VENC_STREAM_PACKITEM_S {
    uint8_t *pData;      // 码流数据地址
    uint32_t u32DataLen; ///< size of encoded data
} HAL_VENC_STREAM_PACKITEM_S;

typedef struct _HAL_VENC_STREAM_S_ {
    HAL_VENC_STREAM_PACKITEM_S stPack[VENC_PACK_MAX];
    uint64_t u64TimeStamp;             // 时间戳，单位：us
    uint32_t u32Cnt;                   // 帧序号
    HAL_STREAM_ENCODE_TYPE_E eEncType; // 视频类型，264 265 jpeg
    uint8_t *pRelHandler;
    int8_t s8Flag; // I帧 P帧信息 1表示I帧
    uint8_t u8PackNum;
    uint8_t res[2]; // 预留
} HAL_VENC_STREAM_S;
/*----------------------------------------------------------------------------*/
/*                                 video_vo 结构体定义                         */
/*----------------------------------------------------------------------------*/
typedef enum {
    HAL_VO_INTF_CVBS,
    HAL_VO_INTF_BT656,
    HAL_VO_INTF_BT1120,
    HAL_VO_INTF_HDMI,
    HAL_VO_INTF_MIPI,
    HAL_VO_INTF_LCD,
} HAL_VO_INTFTYPE_E;

typedef enum {
    HAL_VIDEO_STANDARD_PAL = 0, ///< PAL
    HAL_VIDEO_STANDARD_NTSC,    ///< NTSC
    HAL_VIDEO_STANDARD_SECAM,   ///< SECAM
    HAL_VIDEO_STANDARD_NR
} HAL_VO_VIDEOSTANDARD_E;

typedef struct _HAL_VO_PARAM_CFG_S_ {
    HAL_VO_VIDEOSTANDARD_E eVidStd;
    HAL_VO_INTFTYPE_E eVoIntfType;
    HAL_BASE_RECT_S stRect;   // 实际显示的位置
    HAL_BASE_RECT_S stScreen; // 屏幕的大小
    uint8_t u8Fps;
    uint8_t res[7]; // 预留
} HAL_VO_PARAM_CFG_S;
/*----------------------------------------------------------------------------*/
/*                                 isp  结构体定义                      		      */
/*----------------------------------------------------------------------------*/
// 日夜切换自动模式下最大最小灵敏度
#define HAL_ISP_NDC_MAX_SENS (5u)
#define HAL_ISP_NDC_MIN_SENS (1u)
// 最大等级
#define HAL_ISP_MAX_LVL (100u)
// 人脸曝光最大最小等待时间
#define HAL_ISP_FE_MAX_TIME (60u)
#define HAL_ISP_FE_MIN_TIME (1u)

// 场景模式
typedef enum _ISP_SCENE_ {
    ISP_SCENE_INVALID = 0x0,

    ISP_SCENE_IN,    // 室内
    ISP_SCENE_IR,    // 黑白
    ISP_SCENE_LOW,   // 低照
    ISP_SCENE_BACK,  // 逆光
    ISP_SCENE_FRONT, // 顺光

    ISP_SCENE_BUTT,
} HAL_ISP_SCENE_E;

// 日夜控制类型
typedef enum _ISP_DN_TYPE_ {
    ISP_DN_TYPE_INVALID = 0x0,

    ISP_DN_TYPE_AUTO,  // 自动 不支持
    ISP_DN_TYPE_DAY,   // 白天
    ISP_DN_TYPE_NIGHT, // 夜晚

    ISP_DN_TYPE_BUTT,
} HAL_ISP_DN_TYPE_E;

// 日夜切换参数
typedef struct _ISP_DN_CFG_ {
    HAL_ISP_DN_TYPE_E eType; // 切换类型
    uint32_t u32Sens;        // 灵敏度，范围[ISP_NDC_MIN_SENS，ISP_NDC_MAX_SENS]
} HAL_ISP_DN_CFG_S;

// 曝光类型
typedef enum _ISP_EXP_TYPE_ {
    ISP_EXP_TYPE_INVALID = 0x0,

    ISP_EXP_TYPE_AUTO, // 自动
    ISP_EXP_TYPE_MANU, // 手动

    ISP_EXP_TYPE_BUTT,
} HAL_ISP_EXP_TYPE_E;

// 自动曝光特有参数
typedef struct _ISP_EXP_AUTO_ {
    uint32_t u32MaxTime; // 最大曝光时间，范围(0,帧间隔]，单位：us
    uint32_t u32MinTime; // 最小曝光时间，范围(0,maxTime]，单位：us
} HAL_ISP_EXP_AUTO_S;

// 手动曝光特有参数
typedef struct _ISP_EXP_MANU_ {
    uint32_t u32Time; /* 曝光时间，范围(0,帧间隔]，单位：us */
    uint8_t res[4];   // 预留
} HAL_ISP_EXP_MANU_S;

// 曝光参数
typedef struct _ISP_EXP_CFG_ {
    HAL_ISP_EXP_TYPE_E eType; // 曝光类型
    uint32_t u32MaxGain;      // 曝光最大增益，范围[0, HAL_ISP_MAX_LVL]
    union {
        HAL_ISP_EXP_AUTO_S stAutoCfg; // type为 ISP_EXP_TYPE_AUTO 时有效
        HAL_ISP_EXP_MANU_S stManuCfg; // type为 ISP_EXP_TYPE_MANU 时有效
    };
} HAL_ISP_EXP_CFG_S;

// 测光类型
typedef enum _ISP_METER_TYPE_ {
    ISP_METER_TYPE_INVALID = 0x0,

    ISP_METER_TYPE_NORMAL, // 普通模式，都不开启
    ISP_METER_TYPE_BLC,    // 背光补偿
    ISP_METER_TYPE_HLC,    // 强光抑制

    ISP_METER_TYPE_BUTT,
} HAL_ISP_METER_TYPE_E;

// 背光补偿类型
typedef enum _ISP_BLC_TYPE_ {
    ISP_BLC_TYPE_INVALID = 0x0,

    ISP_BLC_TYPE_DISABLE, // 关闭
    ISP_BLC_TYPE_UP,      // 上
    ISP_BLC_TYPE_DOWN,    // 下
    ISP_BLC_TYPE_LEFT,    // 左
    ISP_BLC_TYPE_RIGHT,   // 右
    ISP_BLC_TYPE_CENTER,  // 中
    ISP_BLC_TYPE_CUSTOM,  // 自定义
    ISP_BLC_TYPE_AUTO,    // 自动

    ISP_BLC_TYPE_BUTT,
} HAL_ISP_BLC_TYPE_E;

// 背光补偿参数
typedef struct _ISP_METER_BLC_ {
    HAL_ISP_BLC_TYPE_E eType; // 背光补偿类型
    uint8_t res[4];           // 预留
    union {
        HAL_BASE_RECT_S stCusRect; // 自定义背光补偿矩形框
        struct {
            uint8_t u8Level; // 自动背光补偿等级，范围[0,HAL_ISP_MAX_LVL]
            uint8_t res[7];
        } stAutolvl;
    };
} HAL_ISP_METER_BLC_S;

// 强光抑制参数
typedef struct _ISP_METER_HLC_ {
    uint8_t u8Level; // 强光抑制等级，范围[0,HAL_ISP_MAX_LVL]
    uint8_t res[7];  // 预留
} HAL_ISP_METER_HLC_S;

// 测光参数
typedef struct _ISP_METER_CFG_ {
    HAL_ISP_METER_TYPE_E eType; // 测光类型
    uint8_t res[4];             // 预留
    union {
        HAL_ISP_METER_BLC_S stBlc;
        HAL_ISP_METER_HLC_S stHlc;
    };
} HAL_ISP_METER_CFG_S;

// 颜色参数，范围[0,HAL_ISP_MAX_LVL]
typedef struct _ISP_COLOR_CFG_ {
    uint8_t u8Brightness; // 亮度
    uint8_t u8Hue;        // 色度
    uint8_t u8Contrast;   // 对比度
    uint8_t u8Saturation; // 饱和度
    uint8_t u8Sharpen;    // 锐度
    uint8_t res[3];       // 预留
} HAL_ISP_COLOR_CFG_S;

// 白平衡类型
typedef enum _ISP_WB_TYPE_ {
    ISP_WB_TYPE_INVALID = 0x0,

    ISP_WB_TYPE_MANUAL,       /* 手动 */
    ISP_WB_TYPE_AUTO,         /* 自动 */
    ISP_WB_TYPE_LOCK,         /* 锁定 */
    ISP_WB_TYPE_INCANDESCENT, /* 白炽灯 */
    ISP_WB_TYPE_WARM,         /* 暖光灯 */
    ISP_WB_TYPE_NATURAL,      /* 自然光 */
    ISP_WB_TYPE_FLUORESCENT,  /* 日光灯 */

    ISP_WB_TYPE_BUTT,
} HAL_ISP_WB_TYPE_E;

// 手动白平衡参数
typedef struct _ISP_WB_MANU_ {
    uint8_t u8Redgain;  // 红色分量增益，范围[0,HAL_ISP_MAX_LVL]
    uint8_t u8Bluegain; // 蓝色分量增益，范围[0,HAL_ISP_MAX_LVL]
    uint8_t res[2];     // 预留
} HAL_ISP_WB_MANU_S;

// 白平衡参数
typedef struct _ISP_WB_CFG_ {
    HAL_ISP_WB_TYPE_E eType; // 类型
    union {
        HAL_ISP_WB_MANU_S stManu;
    };
} HAL_ISP_WB_CFG_S;

// 去雾参数
typedef struct _ISP_DEFOG_CFG_ {
    bool bEnable;    // 是否开启
    uint8_t u8Level; // 等级，范围[0,HAL_ISP_MAX_LVL]
    uint8_t res[3];  // 预留
} HAL_ISP_DEFOG_CFG_S;

// 降噪参数
typedef struct _ISP_NOISE_CFG_ {
    bool bEnable;     // 是否开启
    uint8_t u8LevelS; // 空域降噪级别
    uint8_t u8LevelT; // 时域降噪级别
    uint8_t res[2];   // 预留
} HAL_ISP_NOISE_CFG_S;

// 宽动态参数
typedef struct _ISP_WDR_CFG_ {
    bool bEnable;    // 是否开启
    uint8_t u8Level; // 等级，范围[0,HAL_ISP_MAX_LVL]
    uint8_t res[3];  // 预留
} HAL_ISP_WDR_CFG_S;

// 补光类型
typedef enum _ISP_SUPPLY_TYPE_ {
    ISP_SUPPLY_TYPE_INVALID = 0x0,

    ISP_SUPPLY_TYPE_OFF,  // 关闭
    ISP_SUPPLY_TYPE_AUTO, // 自动
    ISP_SUPPLY_TYPE_MANU, // 手动

    ISP_SUPPLY_TYPE_BUTT,
} HAL_ISP_SUPPLY_TYPE_E;

// 补光参数
typedef struct _ISP_SUPPLY_CFG_ {
    HAL_ISP_SUPPLY_TYPE_E eType; // 类型
    union {
        struct {
            uint8_t u8Level; // 手动补光等级，范围[0,HAL_ISP_MAX_LVL]
            uint8_t res[3];
        } stManuLevel;
    };
} HAL_ISP_SUPPLY_CFG_S;

// 人脸曝光参数
typedef struct _ISP_FE_CFG_ {
    bool bEnable;     // 是否开启
    uint32_t u32Aimy; // 参考亮度，范围[0,HAL_ISP_MAX_LVL]
    uint32_t u32Wait; // 等待时间，范围[HAL_ISP_FE_MIN_TIME, HAL_ISP_FE_MAX_TIME]，单位:min
    uint8_t res[4];   // 预留
} HAL_ISP_FE_CFG_S;

// MIRROR/FLIP参数
typedef struct _ISP_MF_CFG_ {
    uint32_t mirror; // 0:关闭 1:开启
    uint32_t flip;   // 0:关闭 1:开启
    uint32_t res[4]; // 预留
} HAL_ISP_MF_CFG_S;

typedef struct {
    uint32_t u32RoiNum;   // ROI区域数量
    uint32_t *pFaceLumaY; // ROI区域亮度
} HAL_ISP_FACE_EXPOSURE_DATA_S;

/*----------------------------------------------------------------------------*/
/*                                 time  结构体定义                      		  */
/*----------------------------------------------------------------------------*/
/// 时间结构体
typedef struct _HAL_SYSTEM_TIME_S_ {
    int32_t s32Year;   ///<
    int32_t s32Month;  ///< January = 1, February = 2, and so on.
    int32_t s32Day;    ///< 1~31
    int32_t s32Wday;   ///< Sunday = 0, Monday = 1, and so on
    int32_t s32Hour;   ///< 0 ~ 23
    int32_t s32Minute; ///< 0 ~ 59
    int32_t s32Second; ///< 0 ~ 59
    int32_t s32Isdst;  ///< 夏令时 0：not，1：yes
} HAL_SYSTEM_TIME_S;

/* 调试等级 */
typedef enum _HAL_DBG_LEVEL_E_ {
    ENUM_HAL_DBG_NONE = 0x0, /* 无信息 */
    ENUM_HAL_DBG_ERR,        /* 错误 */
    ENUM_HAL_DBG_WARN,       /* 警告 */
    ENUM_HAL_DBG_REPO,       /* 报告 */
    ENUM_HAL_DBG_INFO,       /* 信息 */
    ENUM_HAL_DBG_BUTT,       /* 无效值 */
} HAL_DBG_LEVEL_E;

/*----------------------------------------------------------------------------*/
/*                                 智能算法    结构体定义                      		  */
/*----------------------------------------------------------------------------*/

typedef enum _HAL_ALGO_TYPE_E_ {
    ALGO_TYPE_HUMAN_VEHICLE_DET = 0, // 人脸/人形/车辆检测
    ALGO_TYPE_FACE_DET = 1,
    ALGO_TYPE_YOLOV8_DET = 2,        // YOLOv8模型检测
    ALGO_TYPE_NON_MOTOR_ELEV_DET = 3, // 非机动车梯控检测
    ALGO_TYPE_FACE_RECOGNITION = 4,   // 人脸识别

    ALGO_TYPE_NUM_MAX
} HAL_ALGO_TYPE_E;

// 模型路径最大长度（含结尾'\0'）
#ifndef HAL_ALGO_MODEL_PATH_MAX_LEN
#define HAL_ALGO_MODEL_PATH_MAX_LEN (256 + 1)
#endif

// 算法配置参数
typedef struct _HAL_ALGO_CONFIG_S_ {
    HAL_ALGO_TYPE_E enType;    // 算法类型
    uint32_t u32Width;         // 算法通道宽度
    uint32_t u32Height;        // 算法通道高度
    float confidenceThreshold; // 置信度阈值，范围[0.0, 1.0]
    char modelPath[HAL_ALGO_MODEL_PATH_MAX_LEN];
    uint32_t res[2]; // 预留
} HAL_ALGO_CONFIG_S;

typedef struct _HAL_ALGO_STREAM_DATA_S {
    void *pData;         // 算法数据源
    uint32_t u32DataLen; ///< size of algo data
} HAL_ALGO_STREAM_DATA_S;

typedef struct _HAL_ALGO_STREAM_S_ {
    HAL_ALGO_TYPE_E enType; // 算法类型
    HAL_ALGO_STREAM_DATA_S stPack;
    uint64_t u64TimeStamp; // 时间戳，单位：us
    uint8_t *pRelHandler;
    uint32_t u32Cnt; // 帧序号
    uint32_t res[5]; // 预留
} HAL_ALGO_STREAM_S;

#define HAL_ALGO_MAX_NUM (32)
#define HAL_ALGO_CLASS_NAME (32)
#define HAL_ALGO_FEATURE_LEN (64)

/*----------------------------------------------------------------------------*/
/*                                 图片数据结构体定义                          */
/*----------------------------------------------------------------------------*/

// 图片格式枚举
typedef enum _HAL_IMAGE_FORMAT_E_ {
    HAL_IMAGE_FORMAT_INVALID = 0x0,  // 无效格式
    HAL_IMAGE_FORMAT_JPEG,           // JPEG格式
    HAL_IMAGE_FORMAT_PNG,            // PNG格式
    HAL_IMAGE_FORMAT_RGB,            // RGB格式
    HAL_IMAGE_FORMAT_YUV,            // YUV格式

    HAL_IMAGE_FORMAT_BUTT            // 枚举结束标记
} HAL_IMAGE_FORMAT_E;

// 图片数据结构体
typedef struct _HAL_IMAGE_DATA_S_ {
    uint8_t *pData;          // 图片数据指针
    uint32_t u32DataLen;     // 图片数据长度（字节）
    uint32_t u32Width;       // 图片宽度（像素）
    uint32_t u32Height;      // 图片高度（像素）
    HAL_IMAGE_FORMAT_E eFormat; // 图片格式
    uint64_t u64TimeStamp;   // 图片时间戳（单位：微秒）
    uint8_t res[8];          // 保留字段（用于对齐）
} HAL_IMAGE_DATA_S;

typedef struct _HAL_OD_BOX_ {
    int32_t left;   /**< left */
    int32_t top;    /**< top */
    int32_t width;  /**< width */
    int32_t height; /**< height */
} HAL_ALGO_BOX;

typedef struct _HAL_OD_PARAM_ {
    HAL_ALGO_BOX box;
    int32_t confidence;
    char class_name[HAL_ALGO_CLASS_NAME];
} HAL_OD_PARAM;

typedef struct _HAL_ALGO_OD_RESULT_ {
    int32_t obj_num;
    HAL_OD_PARAM obj_para[HAL_ALGO_MAX_NUM];
} HAL_ALGO_OD_RESULT;

// 轨迹状态（参考 ot_common_aidetect.h 的 ot_aidetect_track_status）
typedef enum _HAL_TRACK_STATUS_E_ {
    HAL_TRACK_STATUS_NEW = 0,    // 新轨迹
    HAL_TRACK_STATUS_UPDATE,     // 更新中
    HAL_TRACK_STATUS_DIE,        // 结束/丢失
    HAL_TRACK_STATUS_VALID,      // 未启用跟踪时的有效态
    HAL_TRACK_STATUS_BUTT
} HAL_TRACK_STATUS_E;

typedef struct _HAL_REC_PARAM_ {
    HAL_ALGO_BOX box;
    int32_t confidence;
    char class_name[HAL_ALGO_CLASS_NAME];
    char feature[HAL_ALGO_FEATURE_LEN];

    // 轨迹信息（可选，依赖底层是否开启跟踪）
    int32_t track_id;                 // 轨迹ID；未启用时为-1或0
    HAL_TRACK_STATUS_E track_status;  // 轨迹状态

    uint8_t res_rec[8]; // 预留对齐
} HAL_REC_PARAM;

// 人脸抓拍/识别的扩展参数（在联合体中使用）
typedef struct _HAL_FACE_PARAM_ {
    HAL_REC_PARAM base;   // 通用识别项（必须为第一个成员，保持与 obj_para 布局对齐）

    // 人脸属性（参考 ot_common_face_capture.h）
    int16_t face_yaw;      // 偏航
    int16_t face_roll;     // 翻滚
    int16_t face_pitch;    // 俯仰
    uint16_t face_quality; // 0-100，数值越大质量越好
    uint8_t face_mask;     // 佩戴口罩标志（1是/0否）
    uint8_t res_face[3];   // 对齐保留
} HAL_FACE_PARAM;

typedef struct _HAL_ALGO_REC_RESULT_ {
    HAL_ALGO_TYPE_E enType; // 结果类型（决定联合体使用哪类数据）
    int32_t obj_num;
    union {
        HAL_REC_PARAM obj_para[HAL_ALGO_MAX_NUM];   // 通用结果
        HAL_FACE_PARAM face_para[HAL_ALGO_MAX_NUM]; // 人脸扩展结果
    };

    // 检测大图数据（可选）
    HAL_YUV_FRAME_S stMainImage;  // 完整的大图YUV帧，pY/pUV为空表示未启用
} HAL_ALGO_REC_RESULT;

typedef struct _HAL_ALGO_RESULT_S_ {
    HAL_ALGO_TYPE_E enType; // 算法类型
    union {
        HAL_ALGO_OD_RESULT OdParam;
        HAL_ALGO_REC_RESULT RecParam;
    };
    uint32_t res[5]; // 预留
} HAL_ALGO_RESULT_S;

typedef struct _HAL_SDIO_PARAM_S_ {
    int32_t type; // 0:SD卡 1:前卷 other:not support
    uint32_t mtd_level;

    int32_t res[8];
} HAL_SDIO_PARAM;

#ifdef __cplusplus
}
#endif

#endif // _HAL_STRUCT_H_
